exports.main = async function(event) {
  const { stockCode } = event
  
  try {
    // 1. 先获取总数
    const countResult = await db.collection('a_patent_details')
      .where({ stock_code: stockCode })
      .count()
    
    const total = countResult.total
    const batchSize = 1000
    const batchCount = Math.ceil(total / batchSize)
    
    console.log(`总数据量: ${total}, 分${batchCount}批获取`)
    
    // 2. 并发获取所有数据
    const tasks = []
    for (let i = 0; i < batchCount; i++) {
      const skip = i * batchSize
      tasks.push(
        db.collection('a_patent_details')
          .where({ stock_code: stockCode })
          .skip(skip)
          .limit(batchSize)
          .get()
      )
    }
    
    console.log('开始并发获取数据...')
    const results = await Promise.all(tasks)
    
    // 3. 合并所有数据
    const allPatents = results.reduce((acc, cur) => {
      acc.push(...cur.data)
      return acc
    }, [])
    
    console.log(`数据获取完成，总计: ${allPatents.length}条`)
    
    // 4. 获取最新总数
    const totalCount = await db.collection('a_stock_patent_stats')
      .where({ stock_code: stockCode })
      .get()
      .then(res => res.data[0].total_count)
    
    console.log(`开始计算统计数据，样本总数：${allPatents.length}，专利总数：${totalCount}`)
    
    // 5. 重新计算统计数据
    const stats = calculatePatentStats(allPatents, totalCount)
    
    // 6. 更新统计记录
    await db.collection('a_stock_patent_stats')
      .where({ stock_code: stockCode })
      .update({
        patent_stats: stats,
        sampled_count: allPatents.length,
        update_time: new Date()
      })
      
    console.log('统计数据更新完成')
    return { success: true }
    
  } catch(e) {
    console.error('重新计算统计数据失败:', e)
    return { success: false, error: e.message }
  }
}


// 计算专利统计数据
function calculatePatentStats(patents, totalCount) {
    console.log('开始计算专利统计, 样本数:', patents.length, '总数:', totalCount)
    
    // 添加数据验证
    const validPatents = patents.filter(patent => {
      const isValid = patent && patent.patentNum && patent.patentType
      if (!isValid) {
        console.warn('发现无效专利数据:', patent)
      }
      return isValid
    })
    
    console.log('有效专利数据数量:', validPatents.length)
    
    // 1. 专利类型分布
    const typeCount = {
      '发明专利': 0,
      '实用新型': 0,
      '外观专利': 0
    }
    
    validPatents.forEach(patent => {
      console.log('处理专利类型:', patent.patentType)  // 添加日志
      if (patent.patentType === '外观设计' || patent.patentType === '外观专利') {
        typeCount['外观专利']++
      } else if (patent.patentType) {
        if (!typeCount.hasOwnProperty(patent.patentType)) {
          console.warn('发现未知专利类型:', patent.patentType)  // 添加警告
        }
        typeCount[patent.patentType]++
      }
    })
    
    // 添加日志输出，方便调试
    console.log('专利类型统计:', typeCount)
    
    // 2. IPC分类分布
    const ipcCount = {}
    validPatents.forEach(patent => {
      if (patent.mainCatNum) {
        const mainCat = patent.mainCatNum.substring(0, 3)
        if (!ipcCount[mainCat]) {
          ipcCount[mainCat] = {
            count: 0,
            name: mainCat  // 暂时使用编码作为名称
          }
        }
        ipcCount[mainCat].count++
      }
    })
    
    // 3. 技术领域分布
    const techFields = {}
    validPatents.forEach(patent => {
      if (patent.cat) {
        const field = patent.cat.replace(/;$/, '')
        if (!techFields[field]) {
          techFields[field] = {
            count: 0,
            main_ipc: patent.mainCatNum?.substring(0, 3) || '',
            related_ipcs: new Set()
          }
        }
        techFields[field].count++
        if (patent.mainCatNum) {
          const ipcCode = patent.mainCatNum.substring(0, 4)
          if (ipcCode) {
            techFields[field].related_ipcs.add(ipcCode)
          }
        }
      }
    })
    
    // 返回完整的统计结果
    return {
      type_distribution: {
        sampled: typeCount,  // 直接返回计数对象，让上层处理格式转换
        estimated: {}  // 估算值在上层计算
      },
      ipc_distribution: {
        sampled: ipcCount,  // 直接返回计数对象，让上层处理格式转换
        estimated: {}  // 估算值在上层计算
      },
      tech_field_distribution: {
        fields: techFields  // 直接返回字段对象，让上层处理格式转换
      }
    }
  }